home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2007 September / PCWSEP07.iso / Software / Linux / Linux Mint 3.0 Light / LinuxMint-3.0-Light.iso / casper / filesystem.squashfs / usr / lib / hplip / base / msg.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2007-04-29  |  4.8 KB  |  232 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.5)
  3.  
  4. import sys
  5. import cStringIO
  6. import select
  7. import socket
  8. from g import *
  9. from codes import *
  10.  
  11. def buildResultMessage(msg_type, payload = None, result_code = ERROR_SUCCESS, other_fields = { }):
  12.     other_fields.update({
  13.         'result-code': result_code })
  14.     return buildMessage(msg_type, payload, other_fields)
  15.  
  16.  
  17. def buildMessage(msg_type, payload = None, other_fields = { }):
  18.     if msg_type is None or not msg_type:
  19.         raise Error(ERROR_INVALID_MSG_TYPE)
  20.     
  21.     msg = cStringIO.StringIO()
  22.     msg.write('msg=%s\n' % msg_type.lower())
  23.     if other_fields:
  24.         for k in other_fields:
  25.             msg.write('%s=%s\n' % (k, str(other_fields[k])))
  26.         
  27.     
  28.     if payload is not None:
  29.         msg.write('length=%d\n' % len(str(payload)))
  30.         msg.write('data:\n%s' % str(payload))
  31.     
  32.     return msg.getvalue()
  33.  
  34.  
  35. def parseMessage(message):
  36.     (fields, data_found, data, remaining_msg) = ({ }, False, '', '')
  37.     msg_key_found = False
  38.     second_msg_key = False
  39.     
  40.     try:
  41.         msg = cStringIO.StringIO(message)
  42.     except TypeError:
  43.         raise Error(ERROR_INVALID_MSG_TYPE)
  44.  
  45.     while True:
  46.         pos = msg.tell()
  47.         line = msg.readline().strip()
  48.         if line == '':
  49.             break
  50.         
  51.         if line.startswith('data:'):
  52.             if not msg.read(fields['length']):
  53.                 pass
  54.             data = ''
  55.             data_found = True
  56.             continue
  57.         
  58.         if line.startswith('#'):
  59.             continue
  60.         
  61.         
  62.         try:
  63.             (key, value) = line.split('=', 1)
  64.             key = key.strip().lower()
  65.         except ValueError:
  66.             raise Error(ERROR_INVALID_MSG_TYPE)
  67.  
  68.         if key == 'msg':
  69.             if msg_key_found:
  70.                 second_msg_key = True
  71.                 break
  72.             else:
  73.                 msg_key_found = True
  74.         
  75.         
  76.         try:
  77.             fields[key] = int(value)
  78.         continue
  79.         except ValueError:
  80.             fields[key] = value
  81.             continue
  82.         
  83.  
  84.         None<EXCEPTION MATCH>ValueError
  85.     if second_msg_key:
  86.         msg.seek(pos)
  87.         if not msg.read():
  88.             pass
  89.         remaining_msg = ''
  90.     
  91.     return (fields, data, remaining_msg)
  92.  
  93.  
  94. def sendEvent(sock, msg_type, payload = None, other_fields = { }, timeout = prop.read_timeout):
  95.     m = buildMessage(msg_type, payload, other_fields)
  96.     log.debug('Sending data on channel (%d)' % sock.fileno())
  97.     log.debug(repr(m))
  98.     (r, w, e) = select.select([], [
  99.         sock], [], timeout)
  100.     if w == []:
  101.         raise Error(ERROR_INTERNAL)
  102.     
  103.     
  104.     try:
  105.         sock.send(m)
  106.     except socket.error:
  107.         log.exception()
  108.         raise Error(ERROR_INTERNAL)
  109.  
  110.  
  111.  
  112. def xmitMessage(sock, msg_type, payload = None, other_fields = { }, timeout = prop.read_timeout):
  113.     fields = { }
  114.     data = ''
  115.     result_code = ERROR_INTERNAL
  116.     msg_type = msg_type.lower().strip()
  117.     m = buildMessage(msg_type, payload, other_fields)
  118.     log.debug('(xmit) Sending data on channel (%d)' % sock.fileno())
  119.     log.debug(repr(m))
  120.     (r, w, e) = select.select([], [
  121.         sock], [], timeout)
  122.     if w == []:
  123.         raise Error(ERROR_INTERNAL)
  124.     
  125.     
  126.     try:
  127.         sock.send(m)
  128.     except socket.error:
  129.         log.exception()
  130.         raise Error(ERROR_INTERNAL)
  131.  
  132.     read_tries = 0
  133.     read_flag = True
  134.     while read_flag:
  135.         remaining = ''
  136.         read_tries += 1
  137.         if read_tries > 3:
  138.             break
  139.         
  140.         (r, w, e) = select.select([
  141.             sock], [], [], timeout)
  142.         if r == []:
  143.             raise Error(ERROR_INTERNAL)
  144.         
  145.         m = sock.recv(prop.max_message_read)
  146.         if m == '':
  147.             continue
  148.         
  149.         log.debug('(xmit) Reading data on channel (%d)' % sock.fileno())
  150.         while True:
  151.             log.debug(repr(m))
  152.             (fields, data, remaining) = parseMessage(m)
  153.             
  154.             try:
  155.                 result_code = fields['result-code']
  156.             except KeyError:
  157.                 result_code = ERROR_INTERNAL
  158.  
  159.             del fields['result-code']
  160.             
  161.             try:
  162.                 result_msg_type = fields['msg'].lower().strip()
  163.             except KeyError:
  164.                 result_msg_type = ''
  165.  
  166.             del fields['msg']
  167.             if result_msg_type == ''.join([
  168.                 msg_type,
  169.                 'result']) or result_msg_type == 'messageerror':
  170.                 read_flag = False
  171.                 break
  172.             else:
  173.                 log.debug('Ignored out of sequence message')
  174.             if remaining:
  175.                 log.debug('Remaining message')
  176.                 m = remaining
  177.                 continue
  178.             break
  179.     return (fields, data, result_code)
  180.  
  181.  
  182. def recvMessage(sock, timeout = prop.read_timeout):
  183.     fields = { }
  184.     data = ''
  185.     result_code = ERROR_INTERNAL
  186.     read_tries = 0
  187.     read_flag = True
  188.     while read_flag:
  189.         remaining = ''
  190.         read_tries += 1
  191.         if read_tries > 3:
  192.             break
  193.         
  194.         (r, w, e) = select.select([
  195.             sock], [], [], timeout)
  196.         if r == []:
  197.             continue
  198.         
  199.         m = sock.recv(prop.max_message_read)
  200.         if m == '':
  201.             continue
  202.         
  203.         log.debug('(xmit) Reading data on channel (%d)' % sock.fileno())
  204.         while True:
  205.             log.debug(repr(m))
  206.             (fields, data, remaining) = parseMessage(m)
  207.             
  208.             try:
  209.                 result_code = fields['result-code']
  210.             except KeyError:
  211.                 result_code = ERROR_INTERNAL
  212.  
  213.             del fields['result-code']
  214.             
  215.             try:
  216.                 result_msg_type = fields['msg'].lower().strip()
  217.             except KeyError:
  218.                 result_msg_type = ''
  219.  
  220.             del fields['msg']
  221.             if result_msg_type == 'messageerror':
  222.                 read_flag = False
  223.                 break
  224.             
  225.             if remaining:
  226.                 log.debug('Remaining message')
  227.                 m = remaining
  228.                 continue
  229.             break
  230.     return (fields, data, result_code)
  231.  
  232.